"""作业：
1、写函数,将传入的列表或元祖对象的奇数位索引对应的元素
2、写函数,判断用户传入的对象(string,list,tuple)长度是否大于5
3、写函数,计算传入的string中,数字,字母,空格以及其它内容的个数,并返回结果
4、写函数,接收两个数字参数,返回较大的那个数字
5、编写一个函数cacluate, 可以接收任意多个数,返回的是一个元组.
6、编写一个函数, 接收字符串参数, 返回一个元组,元组的第一个值为大写字母的个数, 第二个值为小写字母个数.
7、编写函数, 接收一个列表(包含30个1~100之间的随机整形数)和一个整形数k, 返回一个新列表.
函数需求:
将列表下标k之前对应(不包含k)的元素逆序;
将下标k及之后的元素逆序;
8、编写函数，从键盘输入参数x和n，计算并显示形如x+xx +xxx + xxxx + xxxxx+xxx…xxx+ 的表达式前n项的值
9、写函数,函数接收的4个参数分别是:姓名,性别(默认为男),年龄,地址
10、写函数,接收n个数字,返回这些数字的和(动态传参)
11、在实参中传入多个可迭代对象(要有string,list,tuple,set,dict),将每个对象的每个元素都加到args或kwargs里
12、写函数,把传过来的列表中的每一个元素都用"_"拼接,并返回
13、写函数,传入一个数字,返回这个数的阶乘。示例：1x2x3....
14、写函数,返回一个扑克牌列表,里面有52项,每一项都是一个tuple
15、编写函数，求1+2+3+…N的和
16、编写一个函数，求多个数中的最大值
17、编写一个函数，提取指定字符串中所有的字母，然后拼接在一起产生一个新的字符串
18、写一个函数，求多个数的平均值
19、写一个自己的len函数，统计指定序列中元素的个数
20、找出传入的列表或元组的奇数位对应的元素，并返回一个新的列表
21、水仙花数：个位、十位、百位的立方加在一起等于数的本身
22、 定义函数，有一个形参，传入的是列表，数组大小不超过 100个，
数组中的每个元素值不允许超过 100，但是可以等于100，
如果列表大小超过了100个截取到第100个为止，要求返回的列表格式：
删除所有重复元素，使得每个元素只出现一次
按照数字的大小，由高到低排序返回0
23、定义函数 getLength，打印用户传入的容器类型和数据长度
24、定义函数 generateNum( )
25、定义函数 moreThan(num)，判断输入的数字是否大于1500
26、定义函数，有两个形参，第一个形参到第二个形参的范围，所有平方数之和
27、写函数，检查传入字典的每一个value长度，如果大于2，
那么仅保留前两个长度的内容， 并将新内容返回给调用者
 28、写函数，判断用户传入的对象（字符串、列表、元组）的元素是否为空
29、编写自定义函数，完成一个简单的减法运算函数
30、编写自定义函数，可以输出自己的名字即可。
31、编写自定义函数：剪刀石头布
游戏开始，初始状态下用户和电脑都有 100 分，赢一局+10 分，输一局-10 分。

 当用户为 0 分时，游戏结束，提示游戏结束，比赛输了
32、编写一个函数，接受一个字符串作为参数，并返回该字符串的逆序字符串
33、编写一个函数，接受一个数字列表作为参数，并返回其中所有偶数的列表
34、编写一个函数，接受一个字符串列表作为参数，并返回其中最长的字符串。
35、编写一个函数，接受一个数字列表作为参数，并返回其中所有数字的平方的总和
36、编写一个函数，接受一个字符串作为参数，并返回其中所有单词的首字母的大写形式
37、编写一个函数，接受两个列表作为参数，并返回两个列表的交集
举例：
list1 = [100,200,300,454]
list2 = [454,789,125,46]
返回：[454]
 38、定义一个学生注册函数enroll()，打印学生姓名，性别，年龄，城市， 使用默认参数降低调用函数的复杂度
"""

import random

# 1、写函数,将传入的列表或元祖对象的奇数位索引对应的元素
"""
def fun(lis):
    return lis[1::2]


a = fun((1, 2, 3, 4, 5))
print(a)
"""
# 2、写函数,判断用户传入的对象(string,list,tuple)长度是否大于5
"""
def fun(s):
    if len(s) > 5:
        return "你输入的字符串长度大于5"
    elif len(s) == 5:
        return "你输入的字符串长度等于5"
    else:
        return "你输入的字符串长度小于5"


str1 = fun("asdfgh")
list1 = fun([1, 2, 3, 4, 5])
tuple1 = fun((1, 2, 3))
print(str1,list1,tuple1)
"""
# 3、写函数,计算传入的string中,数字,字母,空格以及其它内容的个数,并返回结果
"""
wyx = input("请你输入一个string:")


def fun():
    global wyx
    str1 = 0
    int1 = 0
    space = 0
    other = 0
    for i in wyx:
        if i in "0123456789":
            int1 += 1
        elif i in " ":
            space += 1
        elif ("a" <= i <= "z") or ("A" <= i <= "Z"):
            str1 += 1
        else:
            other += 1
    return str1, int1, space, other


s = fun()
print(s)
"""
# 4、写函数,接收两个数字参数,返回较大的那个数字
"""
def compare(a, b):
    if a > b:
        return a
    elif a < b:
        return b
    else:
        return f"a等于b{a}"


c = compare(10, 20)
print(c)
"""
# 5、编写一个函数cacluate, 可以接收任意多个数,返回的是一个元组.
"""
def cacluate(a):
    return a


print(cacluate(12115, 5545, 115))
"""
# 6、编写一个函数, 接收字符串参数, 返回一个元组,元组的第一个值为大写字母的个数, 第二个值为小写字母个数.
"""
def count_str(a):
    max_str = 0
    min_str = 0
    for i in a:
        if 'a' <= i <= 'z':
            min_str += 1
        elif 'A' <= i <= 'Z':
            max_str += 1
    return max_str,min_str
print(count_str("AAaa"))
"""
# 7、编写函数, 接收一个列表(包含30个1~100之间的随机整形数)和一个整形数k, 返回一个新列表.
# 函数需求:
# 将列表下标k之前对应(不包含k)的元素逆序;
# 将下标k及之后的元素逆序;
"""
list1 = []
for i in range(30):
    a = random.randint(1,100)
    list1.append(a)

print(list1)

def list_fun(k):
    list1 = []
    for i in range(30):
        a = random.randint(1,100)
        list1.append(a)
    before_list1 = list1[:k][::-1]
    after_list1 = list1[k:][::-1]
    return after_list1 + before_list1


print(list_fun(5))
"""
"""
def list_fun(k):
    list1 = []
    for i in range(30):
        a = random.randint(1,100)
        list1.append(a)
    print(list1)
    before_list1 = list1[:k][::-1]
    after_list1 = list1[k:][::-1]
    return before_list1+after_list1


print(list_fun(5))
"""
# 8、编写函数，从键盘输入参数x和n，计算并显示形如x+xx +xxx + xxxx + xxxxx+xxx…xxx+ 的表达式前n项的值
"""
def count_num(x, n):
    result = 0
    for i in range(1, n + 1):
        term = str(x) * i
        print(term)
        result += int(term)
    return result


x_input = int(input("请你输入参数x:"))
n_input = int(input("请你输入参数n:"))
print(count_num(x_input, n_input))
"""
# 9、写函数,函数接收的4个参数分别是:姓名,性别(默认为男),年龄,地址
"""
def id_info(name, age, address, sex='男'):
    print(f"姓名:{name},性别:{sex},年龄:{age},地址:{address}")


id_info('wyx', 23, '朝阳')
"""
# 10、写函数,接收n个数字,返回这些数字的和(动态传参)
"""
def sum_count(*b):
    result = sum(b)
    return result


print(sum_count(1, 2, 3, 4, 5, 6, 7, 8, 9))
"""
# 11、在实参中传入多个可迭代对象(要有string,list,tuple,set,dict),将每个对象的每个元素都加到args或kwargs里
# 12、写函数,把传过来的列表中的每一个元素都用"_"拼接,并返回
# 13、写函数,传入一个数字,返回这个数的阶乘。示例：1x2x3....
"""
def factorial(n):
    result = 1
    for i in range(1,n+1):
        result *= i
    return result
print(factorial(5))
"""
# 14、写函数,返回一个扑克牌列表,里面有52项,每一项都是一个tuple
"""
def poker():
    type_pk = ['红', '黑', '草', '方']
    num_pk = ['A', '2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K']
    deck =[]
    for i in type_pk:
        for j in num_pk:
            deck.append((i,j))
    return deck
print(poker())
"""
# 15、编写函数，求1+2+3+…N的和
"""
def factorial(n):
    result = 0
    for i in range(1,n+1):
        result += i
    return result
print(factorial(5))
"""
# 16、编写一个函数，求多个数中的最大值
"""
def max_num(*num):
    return max(num)
print(max_num(1,2,88,5,6))
"""
# 17、编写一个函数，提取指定字符串中所有的字母，然后拼接在一起产生一个新的字符串
"""
def letter(str1):
    result = ''
    for i in str1:
        if 'a'<=i<='z' or 'A'<=i<'Z':
            result += i
    return result
print(letter("asnA123"))
"""
# 18、写一个函数，求多个数的平均值
"""
def avg_num(*num):
    print(sum(num)/len(num))
avg_num(1,2,3,4)
"""
# 19、写一个自己的len函数，统计指定序列中元素的个数
"""
def my_len(*num):
    count = 0
    for i in num:
        count += 1
    return count
print(my_len(1,23,45,6))
"""
# 20、找出传入的列表或元组的奇数位对应的元素，并返回一个新的列表
"""
def odd_num(odd):
    return odd[1::2]
print(odd_num([1,2,3,4]))
print(odd_num((1,23,45,65)))
"""


# 21、水仙花数：个位、十位、百位的立方加在一起等于数的本身
# 22、 定义函数，有一个形参，传入的是列表，数组大小不超过 100个，数组中的每个元素值不允许超过 100，
# 但是可以等于100，如果列表大小超过了100个截取到第100个为止，要求返回的列表格式：
# 删除所有重复元素，使得每个元素只出现一次
# 按照数字的大小，由高到低排序返回
# 23、定义函数 getLength，打印用户传入的容器类型和数据长度
# 24、定义函数 generateNum( )
# 25、定义函数 moreThan(num)，判断输入的数字是否大于1500
# 26、定义函数，有两个形参，第一个形参到第二个形参的范围，所有平方数之和
# 27、写函数，检查传入字典的每一个value长度，如果大于2,那么仅保留前两个长度的内容， 并将新内容返回给调用者
def long(str_list):
    longest_str = str_list[0]
    for i in str_list:
        if len(i) > len(longest_str):
            longest_str = i
    return longest_str


print(long(["aaa", "ascc", "adewfff","ss"]))
